{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TensorFlow 2.0.0\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import pickle\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras.preprocessing.text import Tokenizer\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "from tensorflow.keras.layers import Embedding, GRU, Dense \n",
    "print('TensorFlow',tf.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading the dataset using tensorflow_datasets "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>We took a taxi so we wouldn't be late.</td>\n",
       "      <td>Nous avons pris un taxi pour ne pas être en re...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Are you in any of those pictures?</td>\n",
       "      <td>Es-tu sur une de ces photos ?</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>I have a lot of passwords to remember.</td>\n",
       "      <td>Il y a beaucoup de mots de passe dont je dois ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Do you have the same thing in a different color?</td>\n",
       "      <td>As-tu la même chose dans une couleur différente ?</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>The petals floated on the surface of the water.</td>\n",
       "      <td>Les pétales flottaient à la surface de l'eau.</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                  0  \\\n",
       "0            We took a taxi so we wouldn't be late.   \n",
       "1                 Are you in any of those pictures?   \n",
       "2            I have a lot of passwords to remember.   \n",
       "3  Do you have the same thing in a different color?   \n",
       "4   The petals floated on the surface of the water.   \n",
       "\n",
       "                                                   1  \n",
       "0  Nous avons pris un taxi pour ne pas être en re...  \n",
       "1                      Es-tu sur une de ces photos ?  \n",
       "2  Il y a beaucoup de mots de passe dont je dois ...  \n",
       "3  As-tu la même chose dans une couleur différente ?  \n",
       "4      Les pétales flottaient à la surface de l'eau.  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "data=pd.read_csv('fra.txt',header=None,sep='\\t')\n",
    "dataset=data.drop(columns = [2])\n",
    "dataset=dataset.sample(8000).reset_index(drop=True)  \n",
    "dataset.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8000"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NUM_SAMPLES = len(dataset)\n",
    "NUM_SAMPLES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding start and end sequence markers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Are you in any of those pictures?'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[0][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 8000/8000 [00:00<00:00, 35774.18it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([\"We took a taxi so we wouldn't be late.\",\n",
       "  'Are you in any of those pictures?',\n",
       "  'I have a lot of passwords to remember.',\n",
       "  'Do you have the same thing in a different color?',\n",
       "  'The petals floated on the surface of the water.'],\n",
       " ['startseq Nous avons pris un taxi pour ne pas être en retard. endseq',\n",
       "  'startseq Es-tu sur une de ces photos\\xa0? endseq',\n",
       "  'startseq Il y a beaucoup de mots de passe dont je dois me rappeler. endseq',\n",
       "  'startseq As-tu la même chose dans une couleur différente ? endseq',\n",
       "  \"startseq Les pétales flottaient à la surface de l'eau. endseq\"])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "en_sentences = []\n",
    "fr_sentences = []\n",
    "for i in tqdm(range(NUM_SAMPLES)):\n",
    "    en_sentences.append(dataset[0][i])\n",
    "    fr_sentences.append('startseq ' + dataset[1][i] + ' endseq')\n",
    "en_sentences[:5],fr_sentences[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tokenization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "en_tk = Tokenizer(num_words=5000)\n",
    "fr_tk = Tokenizer(num_words=5000)\n",
    "\n",
    "with open('en.pkl', 'wb') as f:\n",
    "    pickle.dump(en_tk, f)\n",
    "\n",
    "with open('fr.pkl', 'wb') as f:\n",
    "    pickle.dump(fr_tk, f)\n",
    "    \n",
    "en_tk.fit_on_texts(en_sentences)\n",
    "fr_tk.fit_on_texts(fr_sentences)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with open('en.pkl', 'rb') as f:\n",
    "#     en_tk = pickle.load( f)\n",
    "\n",
    "# with open('fr.pkl', 'rb') as f:\n",
    "#     fr_tk = pickle.load(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualizing sequence lenghts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "English sentences : mean = 6.16975, std = 2.5116100289455767, max = 25\n",
      "Franch sentences : mean = 8.721375, std = 2.786394284622153, max = 30\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "en_lens = [len(x.split()) for x in en_sentences]\n",
    "fr_lens = [len(x.split()) for x in fr_sentences]\n",
    "\n",
    "plt.figure()\n",
    "plt.hist(en_lens)\n",
    "\n",
    "plt.figure()\n",
    "plt.hist(fr_lens)\n",
    "\n",
    "en_mean = np.mean(en_lens)\n",
    "en_std = np.std(en_lens)\n",
    "fr_mean = np.mean(fr_lens)\n",
    "fr_std = np.std(fr_lens)\n",
    "en_max = np.max(en_lens)\n",
    "fr_max = np.max(fr_lens)\n",
    "\n",
    "print(f'English sentences : mean = {en_mean}, std = {en_std}, max = {en_max}')\n",
    "print(f'Franch sentences : mean = {fr_mean}, std = {fr_std}, max = {fr_max}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_sequence_len = 30\n",
    "en_vocab_size = 5000\n",
    "fr_vocab_size =5000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tokenization and sequence padding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_en(en):\n",
    "    encoded_en = en_tk.texts_to_sequences(en)\n",
    "    padded_en = pad_sequences(encoded_en, maxlen=max_sequence_len, padding='post', truncating='post')\n",
    "    return padded_en\n",
    "\n",
    "def preprocess_fr(fr):\n",
    "    encoded_fr = fr_tk.texts_to_sequences(fr)\n",
    "    padded_fr = pad_sequences(encoded_fr, maxlen=max_sequence_len, padding='post', truncating='post')\n",
    "    return padded_fr\n",
    "\n",
    "def preprocess_text(en, fr):\n",
    "    return preprocess_en(en.numpy().decode()), preprocess_fr(fr.numpy().decode())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing training dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_en = preprocess_en(en_sentences)\n",
    "train_fr = preprocess_fr(fr_sentences)\n",
    "\n",
    "batch_size = 64\n",
    "train_dataset = tf.data.Dataset.from_tensor_slices((train_en, train_fr))\n",
    "train_dataset = train_dataset.cache()\n",
    "train_dataset = train_dataset.shuffle(1024)\n",
    "train_dataset = train_dataset.batch(batch_size, drop_remainder=True)\n",
    "train_dataset = train_dataset.prefetch(tf.data.experimental.AUTOTUNE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defininf Encoder, Decoder and Attention models using tf.keras model subclassing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Encoder(tf.keras.Model):\n",
    "    def __init__(self, hidden_size=1024, max_sequence_len=30, batch_size=batch_size, embedding_dim=256, vocab_size=5000):\n",
    "        super(Encoder, self).__init__()\n",
    "        self.embedding_dim = embedding_dim\n",
    "        self.vocab_size = vocab_size\n",
    "        self.max_sequence_len = max_sequence_len\n",
    "        self.hidden_size = hidden_size\n",
    "        self.batch_size = batch_size\n",
    "\n",
    "        self.embedding_layer = Embedding(\n",
    "            input_dim=self.vocab_size, output_dim=self.embedding_dim)\n",
    "        self.GRU_1 = GRU(units=hidden_size, return_sequences=True)\n",
    "        self.GRU_2 = GRU(units=hidden_size,\n",
    "                         return_sequences=True, return_state=True)\n",
    "\n",
    "    def initial_hidden_state(self):\n",
    "        return tf.zeros(shape=(self.batch_size, self.hidden_size))\n",
    "\n",
    "    def call(self, x, initial_state, training=False):\n",
    "        x = self.embedding_layer(x)\n",
    "        x = self.GRU_1(x, initial_state=initial_state)\n",
    "        x, hidden_state = self.GRU_2(x)\n",
    "        return x, hidden_state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意力机制\n",
    "在 Attention 机制下，语义编码 C 就不在是输入序列的直接编码了，而是各个元素按其重要程度加权求和得到的，即：\n",
    "$$C_i=\\sum_{j=0}^{T_x}{a_{ij}h_j}$$\n",
    "在上述公式中，参数i表示时刻， j表示序列中的第j个元素， $T_x$表示序列的长度，$a_{ij}$可以看作是一个概率，反映了元素$h_j对$C_i$的重要性，可以使用 softmax 来表示：\n",
    "$$a_{ij}=\\frac{exp(e_{ij})}{\\sum_{k=1}^{T_x}exp(e_{ik})}$$\n",
    "\n",
    "这里$e_{ij}$正是反映了待编码的元素和其它元素之间的匹配度，当匹配度越高时，说明该元素对其的影响越大，则$a_{ij}$的值也就越大。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Attention(tf.keras.Model):\n",
    "    def __init__(self, hidden_size=256):\n",
    "        super(Attention, self).__init__()\n",
    "        self.fc1 = Dense(units=hidden_size)\n",
    "        self.fc2 = Dense(units=hidden_size)\n",
    "        self.fc3 = Dense(units=1)\n",
    "\n",
    "    def call(self, encoder_output, hidden_state, training=False):\n",
    "        '''hidden_state : h(t-1)'''\n",
    "        y_hidden_state = tf.expand_dims(hidden_state, axis=1)\n",
    "        y_hidden_state = self.fc1(y_hidden_state)\n",
    "        y_enc_out = self.fc2(encoder_output)\n",
    "        \n",
    "        #get a_ij\n",
    "        y = tf.keras.backend.tanh(y_enc_out + y_hidden_state)\n",
    "        attention_score = self.fc3(y)\n",
    "        attention_weights = tf.keras.backend.softmax(attention_score, axis=1)\n",
    "        \n",
    "        #get c_i\n",
    "        context_vector = tf.multiply(encoder_output, attention_weights)\n",
    "        context_vector = tf.reduce_sum(context_vector, axis=1)\n",
    "\n",
    "        return context_vector, attention_weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Decoder(tf.keras.Model):\n",
    "    def __init__(self, hidden_size=1024, max_sequence_len=30, batch_size=batch_size, embedding_dim=256, vocab_size=5000):\n",
    "        super(Decoder, self).__init__()\n",
    "        self.embedding_dim = embedding_dim\n",
    "        self.vocab_size = vocab_size\n",
    "        self.max_sequence_len = max_sequence_len\n",
    "        self.hidden_size = hidden_size\n",
    "        self.batch_size = batch_size\n",
    "    \n",
    "        self.embedding_layer = Embedding(\n",
    "            input_dim=self.vocab_size, output_dim=self.embedding_dim)\n",
    "        self.GRU = GRU(units=hidden_size,\n",
    "                       return_sequences=True, return_state=True)\n",
    "        self.attention = Attention(hidden_size=self.hidden_size)\n",
    "        self.fc = Dense(units=self.vocab_size)\n",
    "\n",
    "    def initial_hidden_state(self):\n",
    "        return tf.zeros(shape=(self.batch_size, self.hidden_size))\n",
    "\n",
    "    def call(self, x, encoder_output, hidden_state, training=False):\n",
    "        x = self.embedding_layer(x)\n",
    "        context_vector, attention_weights = self.attention(\n",
    "            encoder_output, hidden_state, training=training)\n",
    "        contect_vector = tf.expand_dims(context_vector, axis=1)\n",
    "        x = tf.concat([x, contect_vector], axis=-1)\n",
    "        x, curr_hidden_state = self.GRU(x)\n",
    "        x = tf.reshape(x, shape=[self.batch_size, -1])\n",
    "        x = self.fc(x)\n",
    "        return x, curr_hidden_state, attention_weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining training loop, loss function and optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_object = tf.losses.SparseCategoricalCrossentropy(from_logits=True)\n",
    "optimizer = tf.keras.optimizers.Adam(learning_rate=5e-4)\n",
    "train_accuracy = tf.metrics.SparseCategoricalAccuracy()\n",
    "\n",
    "\n",
    "def loss_function(y_true, y_pred):\n",
    "    loss = loss_object(y_true, y_pred)\n",
    "    mask = 1 - tf.cast(tf.equal(y_true, 0), 'float32')\n",
    "    return tf.reduce_mean(loss * mask)\n",
    "    \n",
    "@tf.function()\n",
    "def training_step(en, fr):    \n",
    "    with tf.GradientTape() as Tape:\n",
    "        encoder_init_state = encoder.initial_hidden_state()\n",
    "        encoder_output, encoder_hidden_state = encoder(en, encoder_init_state, training=True)\n",
    "        decoder_hidden = encoder_hidden_state\n",
    "        loss = 0\n",
    "        acc = []\n",
    "        current_word = tf.expand_dims(fr[:, 0], axis=1)\n",
    "        for word_idx in range(1, max_sequence_len):\n",
    "            next_word = fr[:, word_idx]\n",
    "            logits, decoder_hidden, attention_weights = decoder(current_word, encoder_output, decoder_hidden, training=True)\n",
    "            loss += loss_function(next_word, logits)\n",
    "            acc.append(train_accuracy(next_word, logits))\n",
    "            current_word = tf.expand_dims(next_word, axis=1)\n",
    "    variables = encoder.trainable_variables + decoder.trainable_variables\n",
    "    gradients = Tape.gradient(loss, variables)\n",
    "    optimizer.apply_gradients(zip(gradients, variables))\n",
    "    return loss, tf.reduce_mean(acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoder = Encoder()\n",
    "decoder = Decoder()\n",
    "checkpoint_dir = 'training'\n",
    "checkpoint_prefix = 'training/ckpt'\n",
    "checkpoint = tf.train.Checkpoint(optimizer=optimizer, encoder=encoder, decoder=decoder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/4\n",
      "125/125 [==============================] - 1266s 10s/batch - curr_loss: 1.0478 - curr_accuracy: 0.7373\n",
      "Metrics after epoch 1 : Loss => 1.294 | Accuracy => 0.664\n",
      "Epoch 2/4\n",
      "125/125 [==============================] - 1289s 10s/batch - curr_loss: 1.0233 - curr_accuracy: 0.7633\n",
      "Metrics after epoch 2 : Loss => 1.081 | Accuracy => 0.752\n",
      "Epoch 3/4\n",
      "125/125 [==============================] - 1161s 9s/batch - curr_loss: 0.8113 - curr_accuracy: 0.7759\n",
      "Metrics after epoch 3 : Loss => 0.970 | Accuracy => 0.769\n",
      "Epoch 4/4\n",
      "125/125 [==============================] - 1933s 15s/batch - curr_loss: 0.7466 - curr_accuracy: 0.7845\n",
      "Metrics after epoch 4 : Loss => 0.889 | Accuracy => 0.780\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'training/ckpt-5'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "epochs = 4\n",
    "num_steps = NUM_SAMPLES // batch_size\n",
    "for epoch in range(1, epochs + 1):\n",
    "    print(f'Epoch {epoch}/{epochs}')\n",
    "    ep_loss = []\n",
    "    ep_acc = []\n",
    "    progbar = tf.keras.utils.Progbar(target=num_steps, stateful_metrics=[\n",
    "                                     'curr_loss', 'curr_accuracy'], unit_name='batch')\n",
    "\n",
    "    for step, example in enumerate(train_dataset):\n",
    "        en = example[0]\n",
    "        fr = example[1]\n",
    "        loss, acc = training_step(en, fr)\n",
    "        loss /= fr.shape[1]\n",
    "        ep_loss.append(loss)\n",
    "        ep_acc.append(acc)\n",
    "        progbar.update(\n",
    "            step + 1, values=[('curr_loss', loss), ('curr_accuracy', acc)])\n",
    "\n",
    "    if epoch % 1 == 0:\n",
    "        checkpoint.save(file_prefix=checkpoint_prefix)\n",
    "    print(f'Metrics after epoch {epoch} : Loss => {np.mean(ep_loss):.3f} | Accuracy => {np.mean(ep_acc):.3f}')\n",
    "checkpoint.save(file_prefix=checkpoint_prefix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0xb35849128>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkpoint.restore('training/ckpt-4')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inference function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def translate_sentence(sentence):\n",
    "    print(sentence)\n",
    "    sentence = preprocess_en([sentence])\n",
    "    enc_init = tf.zeros(shape=[1, 1024])\n",
    "    enc_out, enc_hidden = encoder(sentence, enc_init)\n",
    "\n",
    "    decoder.batch_size = 1\n",
    "    fr_tk.index_word[0] = ''\n",
    "    decoded = []\n",
    "    att = []\n",
    "    current_word = tf.expand_dims([fr_tk.word_index['startseq']], axis=0) \n",
    "    decoder_hidden = enc_hidden\n",
    "    for word_idx in range(1, max_sequence_len):\n",
    "        logits, decoder_hidden, attention_weights = decoder(current_word, enc_out, decoder_hidden)\n",
    "        decoded_idx = np.argmax(logits)\n",
    "        if fr_tk.index_word[decoded_idx] == 'endseq':\n",
    "            break\n",
    "        decoded.append(fr_tk.index_word[decoded_idx])\n",
    "        \n",
    "        att.append(attention_weights.numpy().squeeze())\n",
    "        current_word = tf.expand_dims([decoded_idx], axis=0)\n",
    "    return ' '.join(decoded), att"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Translating and visualizing Attention maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There is a misunderstanding\n",
      "EN :  There is a misunderstanding\n",
      "FR :  il est la\n",
      "------------------------------\n",
      "what do you want ?\n",
      "EN :  what do you want ?\n",
      "FR :  pourquoi vous êtes vous\n",
      "------------------------------\n",
      "are you mad ?\n",
      "EN :  are you mad ?\n",
      "FR :  vous êtes\n",
      "------------------------------\n",
      "state of the art\n",
      "EN :  state of the art\n",
      "FR :  ils\n",
      "------------------------------\n",
      "the exam is going to be hard\n",
      "EN :  the exam is going to be hard\n",
      "FR :  la monde est\n",
      "------------------------------\n",
      "do you want to play with me ?\n",
      "EN :  do you want to play with me ?\n",
      "FR :  pourquoi vous êtes vous\n",
      "------------------------------\n",
      "i love you\n",
      "EN :  i love you\n",
      "FR :  je vous\n",
      "------------------------------\n",
      "how are you doing ?\n",
      "EN :  how are you doing ?\n",
      "FR :  pourquoi vous êtes vous\n",
      "------------------------------\n",
      "i should tell you that i am quite dangerous\n",
      "EN :  i should tell you that i am quite dangerous\n",
      "FR :  je n'ai pas que vous me faire ce que vous\n",
      "------------------------------\n",
      "Do you have any idea of how to use it ?\n",
      "EN :  Do you have any idea of how to use it ?\n",
      "FR :  pourquoi vous êtes vous\n",
      "------------------------------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 288x216 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 384x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 360x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 288x144 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe4AAAEOCAYAAABPU/TUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAADEdJREFUeJzt3WusZQdZx+H/2wudptLW3lQ0VFSkRW0rDLeAKFZp/KBRaVoNRMSYRtEgoGCKGvESopTED6jEpgheCIUUUFCk1UaLUaA2pe0UUFChKSCXYhUjDE7L64e9x9Qyl3NOO2fNO/M8yUnOXmflzLuzJvObdd3V3QEAZjhm6QEAgI0TbgAYRLgBYBDhBoBBhBsABhFuABhEuAFgEOEGgEGOW3oAgEOlqh5zoJ93983bNQs8WMqT04AjVVX99frbHUl2Jrk1SSU5L8l7uvspS80GW+VQOXDE6u6ndffTktyR5DHdvbO7H5vkW5P887LTwdYIN3A0OKe7d+190d23J7lgwXlgy5zjhoOoqh/Z1/Lu/sPtnoUt+0BVXZXkj5N0kmcl+cCyI8HWOMcNB1FVr7zPyx1JLkxyc3dfvNBIbFJV7Ujyk0meul70ziSv6u7dy00FWyPc26SqviLJy5I8rLu/p6oeneRJ3f3qhUdjk6rqlCR/1N3ft/QswNHHOe7t89ok1yZ52Pr1B5M8f7FpeCA+l+SRSw/BxlXVI6vqmqp6f1X9696vpeeCrXCOe/uc0d1vrKrLk6S776mqe5ceioOrqrdldV40SY5Ncm6SNy43EVvwmiS/nOS3kjwtyXOyui0MxhHu7fPfVXV61gGoqicm+c9lR2KDXnGf7+9Jckd3f3SpYdiSE7v7+qqq7r4jyUur6m+zijmMItzb54VJ3prk66vq75KcmcTFTQN09w3raxQet170oSXnYUt2V9UxST5UVT+d5GNJzlp4JtgSF6dtg/U/GE9McmOSR2V1iO6funvPooOxIVV1SZIrkvxNVtvu25K8qLuvWXIuNq6qHpfV7V+nJvm1JCcneXl3v2fRwWALhHubVNW7uvtJS8/B5lXVrUm+u7s/tX59ZpK/6u7zl52MjaqqnUl+IcnZSY5fL+7uPm+5qWBrHCrfPtdV1TOSvLn9b2maY/ZGe+0zcUfGNK9L8qIku5J8ceFZ4AER7u3zwiQnJbmnqnZndci1u/vkZcdiA/6iqq5N8vr160uTvH3Bedi8T3f3W5ceAh4MDpVvo6o6Lav7f3fsXdbdNyw3ERtRVc9LcmdW57YryTu7+y3LTsVmVNWFSX44yfVJvrB3eXe/ebGhYIvscW+TqvrxJD+T5GuS3JLVxWp/n9XjMzm8nZXkeUluTvL7WT1Ih1mek+ScrM5v7z1U3kmE+zC13tH5iSS7k1zV3Z9deKTDhj3ubVJVu7K6nejd3X1BVZ2T5Fe6+9KFR2MDqqqSPD2rAOzM6gEsr+7uf1l0MDakqnZ197csPQcbt/4s9XdldYTyoiTf292edhcX2Gyn3Xs/0KCqTujuf8zq1jAGWF9Q+In11z1JvjzJNVX18kUHY6Pevf58AOY4vbtf0t0vzOoaoRuqaldVPb2qjuonFzpUvn0+WlWnJvmTJH9ZVXcn+fjCM7EB63Pcz05yV5KrsrqHe8/eB3okefGS87EhT0ny7Kr6cFbnuPdeHOp2sMPXf1XV13b3R7r72qp6eFaf9XB3VncHHLUcKl9AVX17klOSvKO7/2fpeTiwqvrVrA6L37GPn53b3T7X+TBXVWfva/m+timHh6p6VFb/ufrg0rMcboQbAAZxjhsABhFuABhEuBdSVZctPQNbY9vNZvvNZdutCPdy/AWcy7abzfaby7aLcAPAKIftVeUPqRN6R05aeoxDZk++kONzwtJjsAW23WxH+vb7xvM+t/QIh8ynP3Nvzjz92KXHOGQ+cuee3PXv99bB1jtsH8CyIyflCeUx3gCbce21tyw9Alv0+Ivu3NB6DpUDwCDCDQCDCDcADCLcADCIcAPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADCIcAPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADCIcAPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADCIcAPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADDIAcNdVb9ZVc+9z+uXVtXPVtUVVXV7Ve2qqkvXP/uOqvqz+6z721X1o+vvf6Oq3l9Vt1XVKw7RewGAI97B9rivTnLpfV5fkuSuJBckOT/JdyW5oqq+an+/oKpOS/IDSb6pu89L8usPaGIAOIodMNzd/d4kZ1XVw6rq/CR3ZxXt13f3vd39ySQ3JHncAX7NZ5PsTnJVVf1gks/tb8Wquqyqbqqqm/bkC5t9LwBwxNvIOe5rklyc1Z731UlqP+vdc7/ftyNJuvueJI9P8qYk35/kHfv7g7r7yu7e2d07j88JGxgNAI4uGwn31Ul+KKt4X5PknUkurapjq+rMJE9NcmOSO5I8uqpOqKpTklyYJFX1ZUlO6e63J3l+VnvsAMAWHHewFbr7fVX10CQf6+5/q6q3JHlSkluTdJIXd/cnkqSq3pjktiQfSvLe9a94aJI/raodWe2tv+DBfxsAcHSo7l56hn06uU7rJ9SFS48BMMq1H79l6RHYosdfdGduunX3/k5H/x/3cQPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADCIcAPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADCIcAPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADCIcAPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADCIcAPAIMINAIMct/QA+1MnPCTHPvwRS4/BFn3x1JOWHoEtuvPyXnoEHoDf+Y/PLD0CW/Spez+5ofXscQPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADCIcAPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADCIcAPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADCIcAPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADCIcAPAIMINAIMINwAMsulwV9WTq+oZh2IYAODANhXuqnpEkmcm+Yaq+s71spccisEAgC913GZW7u4PJ3nu/Ra/JMnLHrSJAID92uwe97Oq6saquqWqfq+qrkhy4vr16/azzrHrr9dW1e1VtauqXnBI3g0AHOE2vMddVecmuTTJk7t7T1X9bpJdST7f3RccYJ1nJnlfkq/u7m9er3fqg/w+AOCosJlD5RcmeWySf6iqJDkxyac2uM7bknxdVb0yyZ8nuW5ff0BVXZbksiTZcdzJmxgNAI4Omwl3JfmD7r78/y2s+rmDrbNe7/wkFyX5qSSXJPmx+6/T3VcmuTJJTtnxlb2J2QDgqLCZc9zXJ7m4qs5Kkqo6rarOTrKnqo4/0DpVdUaSY7r7TUl+KcljHry3AABHjw3vcXf3+6vqF5NcV1XHJNmT1d7zlUluq6qbu/uZ+1nn80les16WJF+yRw4AHNxmbwd7Q5I33G/xu5P8/EHWSexlA8AD5pGnADCIcAPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADCIcAPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADCIcAPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADCIcAPAIMINAIMINwAMItwAMIhwA8Agwg0Agwg3AAwi3AAwiHADwCDCDQCDCDcADCLcADCIcAPAINXdS8+wT1X16SR3LD3HIXRGkruWHoItse1ms/3mOtK33dndfebBVjpsw32kq6qbunvn0nOwebbdbLbfXLbdikPlADCIcAPAIMK9nCuXHoAts+1ms/3msu3iHDcAjGKPGwAGEW4AGES4AWAQ4QaAQYQbAAb5XyfIaVZBk3aTAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 288x72 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 504x216 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 672x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 576x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 216x144 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 360x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 648x720 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x320 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 792x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqsAAAEQCAYAAACX/j3aAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAF2VJREFUeJzt3XvUJHV95/H3Zy7McFd0yGoMEIh442YcSFgQXTFyjntMvLAMyhrBZDmiWa8BEzQbNNmNLjF7jKwxE7wASUR3XBclAkaMoBIlGGS4RMUNEGMQxcVwnWEu3/2japzHYYZ5gO6uXzfv1znPoau6nqrvj55++tO/+tWvUlVIkiRJLVowdAGSJEnSthhWJUmS1CzDqiRJkpplWJUkSVKzDKuSJElqlmFVkiRJzTKsSpIkqVmGVUmSJDXLsCpJkqRmGValXpL9k1ya5Lp++aAkbx+6LkmSHs0Mq9Jmfwb8NrAOoKpWA8cPWpEkSY9yhlVps52q6sot1q0fpBJJkgTAoqELkBpye5L9gAJIcixw67Alab6SLAV+DXgGsHTT+qp69WBFaV6SLK2qNUPXIalN9qxKm70O+FPgqUm+C7wReM2wJekhOA/4N8AxwGXAk4C7Bq1I83Vdki8neVeSFybZfeiCJLUjVTV0DVITkiysqg1JdgYWVNVMBZ1N7Ru6jnFJcnVVPTPJ6qo6KMli4JKqet7QtWn7kuwFPBs4Angh8KOqOmTYqiS1wGEAmrckv7q19VV17qRrGZObklwMfAz4/NDFjMG3k6wCPlxVNwxdzBis6//7oyQHAN8D9hmuHM1XkifRhdRnAwcD1wNfGrQoPSRJdgT2qqpvDl2LZo/DAPRQHDrn59nAGcAvD1nQiD0F+BzdcICbkpyV5MiBaxqlg4BvAWcn+UqSk5PsNnRRI7QyyWOB3wE+BdwA/PdhS9I8/RPdsJuLqurwqvr3VfUHQxel+UnyIuDrwMX98iFJPjVsVZolDgPQw9aPKzuvqmYpsALQh573AidU1cKh6xm1JEcBHwUeA6wCfq+qvj1sVXq0SnIwcCRwFLAXcCNwWVV9cNDCNC9JvgY8D/hCVT2zX7e6qg4atjLNCntW9UjcCzx56CJGKclzkrwf+Hu6K8qPG7ikkUmyMMkvJ/kkXRB/D7Av8GngM4MWNwJJfirJB5Nc1C8/PcmvDV2Xtq+qrgHOAT5MNwTnOXQ95JoO66vqX4cuQrPLMasjlmQHYP9+8ZtVte7Btp8mST5NP60TsBB4GvDx4SoarSQ30Z3K+jhwalXdM3BJo3Yj8DfAmVV1xZz1q/qe1mn3Ebqw87Z++Vt044/tnWtckquAJcAVdGNVj6qqW4atSg/BdUleASxM8mTg9XSvpTQSDgMYoSTPpesduBkI8DPAq6rq8gHLGpkkz5mzuB64par+eah6Ri3JblV159B1jEuSXarq7qHrGJckf1dVh26aFaBf93WvKG9fkmVV9YOh69DDk2Qnui+JL6D77LuEbmiRc+dqJOxZHa33AC/YdDVkkv3pxgU+a9CqRqSqLkvyU3QXWEHXUzdL7k/yOmZ3Uvkdk7ye7gr5H7/3Z6h99yR5HJtv6vCLgKcmp8P9Sf6IbswqdPPkvtNTy9Ohqu6lC6tvS7IQ2NmgqlFyzOpoLZ47bUdVfQtYPGA9I5XkOOBK4D/QjeX8an+Xp1kx65PKXwDsTjfjwV/N+ZkVb6abBWC/JF8GzgX+87AlaZ4+RPdeO67/uZNuSIemQJK/TLJbP0f19cA3k5w6dF2aHQ4DGKEkH6Lr1TmvX3UCsKiqThquqtFJcg3wS1X1/X55GfC5qjp42MpGY9YnlX80nBJPsohuCrIwA2PGk5xXVa9M8oaqeu/Q9YzL1v5tztK/1y3OSF256W/orNj0WiU5ge5M4luBrzkbgEbFYQCjdQrdHJ2vp/uwvBx4/6AVjdaCLf7I/pDZ6p2f9UnlL0zywqqa+iv/50ry0m08tX8Squp/T7Sg0XpWkr2BVyc5l+7vyo9V1f8bpqyRuy/JkVX1JYAkRwD3DVzTSPRnpM4EvkD3+r0vyalVtWrQwkZrcf/l/sXAWVW1Lsn2fkeaN8PqCFXV2iTn0c09OosXC1yU5BK6cbgAK5iBKY/m2DSp/NvpTifvwmxNn/MG4PQka+mCeYCqqmm/McCL+v/uCfxbNt997N/RBYRpDqsfoJtofV/ga3PWh+4szr5DFDUGpwDn9HM3A9wBvGrAekbpbcChW56RopvfeFZ8ALgJWA1c3n/BcryxRsZhACOQ7ivk7wK/QfchEmAD8L6qeueQtY1Sf3HOd+juXhXg8qr65LBVjU6SJcDL6HpTN401rhl7Dfegmxt37gVklw1X0egkuRD4T1V1a7/8BOB/VtW2el6nRpI/oQsEmy5Auryfm3Qm9O+9Y4H96G5U8a/MyHsvybVVdeCc5QXANXPXTbskvztnsejOuC2sqpn4sr+1YTizPjSnNbN0CndIb6S7r/WhVfW4qtoD+AXgiCRvGra0kdqT7nTWk+imJvk/w5YzchcAv0I3Ldfd/c/MzLWa5NfpLhy7mO5WuRcD/2XImkZsn01BtXcbm+c8nnbfAP4ceDywDDgvySxdPHYBXQ/5GuC7zNZ776IklyQ5McmJdBc1ztIZKdj89/Juuo6aY4CfHrSi0dpaL/+Jky5ilJLskeT0JG+ehttu27M6Akmuprvw6PYt1i8DPrtpzsdZ0PcivwA4CVhON4H+B6vq/w5a2Agkua6qDhi6jnFJci3dRR5f6S+GeCrwjqpaMXBpI5HkLLpe44/S9e4cD3y7qqY+1CVZDRy+6UYV/VXXfzsrF7DM8nsvybuBr9LdTnbTtQy/WFVvHbSwMep7yj9VVccMXcsjkeTlwCvoXrsvznlqV2BDVT1/kMJGIMnfAH9Ld5btGOBFVfWPw1a1bY5ZHY3FWwZVgKr6QT/ofGZUVSX5Ht3FR+uBx9LdAemvq+q0Yat7xK5IcmBVXTt0IWOypqrWJCHJkqr6RpKnDF3UqFTVb/QXWz27X7VyhoapbBpatMkGtrjYasrN8nvvl/pg+uOx00neQXfF/KzaidkYT30FcCvdGY33zFl/F9343Gn2uKo6HSDJMcBlSX4EvAX49apq6lbjhtXRuP9hPjdV+jGrrwJuB86muyXpun4M1o3AVIbVvsex6N4PJyX5R2Atmy9AmoneK+CfkzyGbvjGXye5A/iXgWsaqf7K/2m+oGpbPkw3r/Gm8P1iZuA2srP83ktyCvBaYN++Z3yTXYEvD1PVeMx5HaG7FfcyYOrHG/e3/L0FOHzoWsbgriT7VNXNVXVJkr2AJ9Jd3Njcl0aHAYxAkg1sfXxVgKVVNRO9q0neSXfK/wH37E7ytKr6hwHKesT6K1e3aRbvUZ7u1rm7AxdX1VR/oUrypao6MsldbP7AhNmZ7QCAJD/PnFPJVXX1wCU9YrP83utnNngs8AfAb8156q4ZmnIMeMDruB64rarWD1XPqMzy35b+rFr1Ny9qnmFVkiRJzXI2AEmSJDXLsDomSU4euoZxsn3TzfZNr1luG9i+aWf7plfLbTOsjk+zL/qI2L7pZvum1yy3DWzftLN906vZthlWJUmS1KxH1QVWO2RJLWXniRxrHWtZzJKJHGsIQ7QvCyb33er+WsMOWbr9DUfkyQfcPbFjAfzghxtY9riFEzvedbcvm9ixADbccw8Ld57Mex1gye2Tm1Dh/g33scPCHSd2PADWb9j+NiMy6fcewCQ/B9fVGhZPtH2T/YxfV2tZnAl+Nkw4wszyZ/uk27aGe7i/1s5rvuhH1TyrS9mZX8jRQ5ehh2nBTpMLH5N20SUzNe3iAzz17FOGLmGs9vuz7wxdwlht/OFMzbT0ALVu6mdZ2rbaOHQFY1UbZ7zDbYZfv69u/Ny8t3UYgCRJkpplWJUkSVKzDKuSJElqlmFVkiRJzTKsSpIkqVmGVUmSJDXLsCpJkqRmGVYlSZLULMOqJEmSmmVYlSRJUrMMq5IkSWqWYVWSJEnNMqxKkiSpWYZVSZIkNcuwKkmSpGYZViVJktQsw6okSZKaZViVJElSswyrkiRJapZhVZIkSc0yrEqSJKlZhlVJkiQ1y7AqSZKkZs1EWE3ymiS/OnQdkiRJGq1FQxw0yaKqWj+q/VXVB0a1L0mSJLVjuz2rSfZJ8o0k5yRZnWRVkp2SHJ3k6iTXJvlQkiX99jcneXz/eHmSL/SPz0iyMslngXOT7Jjk/H6fH0vy1STL+23vnnP8Y5N8pH+8d5JL+9+5NMlec/b9myP+fyNJkqSBzXcYwFOAlVV1EHAn8GbgI8CKqjqQrof2lHns51nAr1TVK/rt7+33+V/757bnLODc/nf+Avjj7f1CkpOTXJXkqnWsncchJEmS1Ir5htXvVNWX+8d/DhwN3FRV3+rXnQMcNY/9fKqq7usfH9Xvi6paDayex+8fDvxl//g84Mjt/UJVrayq5VW1fDFL5nEISZIktWK+YbUewj7Xz9nv0i2eu2ee+527fst9PNy6JEmSNGXmG1b3SnJ4//jlwOeAfZL8XL/ulcBl/eOb2XxK/2UPss/LgRMAkhwAHDTnuduSPC3JAuAlc9ZfARzfPz4B+NI865ckSdIUmm9Y/QfgVUlWA3sA/wM4CfhfSa4FNgKbrsh/B/DeJF8ENjzIPv8E2KXf52nAlXOe+y3gQuDzwK1z1r8eOKn/nVcCb5hn/ZIkSZpC8526amNVvWaLdZcCz9xyw6r6IrD/VtafscXyfWzuJWXTrAH9c6uAVVvZx83A87a3b0mSJM2GmbgpgCRJkmbTdntW+97MA8ZdSFU9d9zHkCRJ0nSxZ1WSJEnNMqxKkiSpWYZVSZIkNcuwKkmSpGYZViVJktQsw6okSZKaZViVJElSswyrkiRJapZhVZIkSc0yrEqSJKlZhlVJkiQ1y7AqSZKkZhlWJUmS1CzDqiRJkpplWJUkSVKzDKuSJElqlmFVkiRJzTKsSpIkqVmGVUmSJDVr0dAFTFIWLmDhLrsNXcbYbNzvZ4YuYay+/fLZfe0O+OODhy5hrPb+/F1DlzBe69YNXcFYZYfFQ5cwXgsXDl3B+GzcOHQFY5WqoUsYrxl+/bIm897WnlVJkiQ1y7AqSZKkZhlWJUmS1CzDqiRJkpplWJUkSVKzDKuSJElqlmFVkiRJzTKsSpIkqVmGVUmSJDXLsCpJkqRmGVYlSZLULMOqJEmSmmVYlSRJUrMMq5IkSWqWYVWSJEnNMqxKkiSpWYZVSZIkNcuwKkmSpGYZViVJktQsw6okSZKaZViVJElSswyrkiRJapZhVZIkSc0yrEqSJKlZhlVJkiQ1y7AqSZKkZk08rCZ5d5LXzlk+I8lbkpyZ5Lok1yZZ0T/33CQXztn2rCQn9o/fleSGJKuT/OGk2yFJkqTxG6Jn9XxgxZzl44DbgUOAg4HnA2cmecK2dpBkD+AlwDOq6iDg98dXriRJkoYy8bBaVVcDeyZ5YpKDgTvogupHq2pDVd0GXAYc+iC7uRNYA5yd5KXAvdvaMMnJSa5KctX9G9eMriGSJEkau6HGrK4CjqXrYT0fyDa2W89P1rgUoKrWA4cBnwBeDFy8rQNV1cqqWl5Vy3dYsHQEpUuSJGlShgqr5wPH0wXWVcDlwIokC5MsA44CrgRuAZ6eZEmS3YGjAZLsAuxeVZ8B3kjXMytJkqQZs2iIg1bV9Ul2Bb5bVbcm+SRwOHANUMBpVfU9gCQfB1YDNwJX97vYFbggyVK6Xtk3TboNkiRJGr9BwipAVR0453EBp/Y/W253GnDaVnZx2PiqkyRJUgucZ1WSJEnNMqxKkiSpWYZVSZIkNcuwKkmSpGYZViVJktQsw6okSZKaZViVJElSswyrkiRJapZhVZIkSc0yrEqSJKlZhlVJkiQ1y7AqSZKkZhlWJUmS1CzDqiRJkpplWJUkSVKzDKuSJElqlmFVkiRJzTKsSpIkqVmGVUmSJDXLsCpJkqRmGVYlSZLULMOqJEmSmrVo6AImaeNOS1lz2JOHLmNs7njKkqFLGKtsrKFLGJs9r1o7dAljteifvj90CWO18a67hy5hvDZsGLqCsaqa3b8tM2+GPxdm3UN55exZlSRJUrMMq5IkSWqWYVWSJEnNMqxKkiSpWYZVSZIkNcuwKkmSpGYZViVJktQsw6okSZKaZViVJElSswyrkiRJapZhVZIkSc0yrEqSJKlZhlVJkiQ1y7AqSZKkZhlWJUmS1CzDqiRJkpplWJUkSVKzDKuSJElqlmFVkiRJzTKsSpIkqVmGVUmSJDXLsCpJkqRmGVYlSZLUrCbCapIjkrxs6DokSZLUlsHDapKfBU4Afi7J8/p1pw9blSRJklqwaOgCquom4LVbrD4d+G8DlCNJkqSGtNCz+h+TXJnk60n+NMmZwI798l9sY5uF/c9HklyX5Nokbxq4KZIkSRqxQXtWkzwNWAEcUVXrkrwfuBa4r6oOeZBtTgCuB366qg7ot3vMII2QJEnS2Aw9DOBo4FnA3yUB2BH4/jy3+TSwb5L3AX8FfHZrB0hyMnAywJKl5llJkqRpMnRYDXBOVf32T6xMfnN72/TbHQwcA7wOOA549ZbbVNVKYCXArrs9qUZXuiRJksZt6DGrlwLHJtkTIMkeSfYG1iVZ/GDbJHk8sKCqPgH8DvDzA9QvSZKkMRq0Z7WqbkjyduCzSRYA6+h6SVcCq5P8fVWdsI1t7gM+3K8DeEDPqyRJkqbb0MMAqKqPAR/bYvVXgLduZxuwN1WSJGmmDT0MQJIkSdomw6okSZKaZViVJElSswyrkiRJapZhVZIkSc0yrEqSJKlZhlVJkiQ1y7AqSZKkZhlWJUmS1CzDqiRJkpplWJUkSVKzDKuSJElqlmFVkiRJzTKsSpIkqVmGVUmSJDXLsCpJkqRmGVYlSZLULMOqJEmSmmVYlSRJUrMMq5IkSWqWYVWSJEnNMqxKkiSpWYuGLmCS1u0a/uWoHYYuY2wW3zV0BeO194X3DV3C2Cy+/pahSxirjWvXDl3CWNWGDUOXIG3dxhq6Aj0SCzJ0BU2wZ1WSJEnNMqxKkiSpWYZVSZIkNcuwKkmSpGYZViVJktQsw6okSZKaZViVJElSswyrkiRJapZhVZIkSc0yrEqSJKlZhlVJkiQ1y7AqSZKkZhlWJUmS1CzDqiRJkpplWJUkSVKzDKuSJElqlmFVkiRJzTKsSpIkqVmGVUmSJDXLsCpJkqRmGVYlSZLULMOqJEmSmmVYlSRJUrMMq5IkSWqWYVWSJEnNMqxKkiSpWRMPq0neneS1c5bPSPKWJGcmuS7JtUlW9M89N8mFc7Y9K8mJ/eN3JbkhyeokfzjpdkiSJGn8huhZPR9YMWf5OOB24BDgYOD5wJlJnrCtHSTZA3gJ8IyqOgj4/QfZ9uQkVyW5asM994yifkmSJE3IxMNqVV0N7JnkiUkOBu6gC6ofraoNVXUbcBlw6IPs5k5gDXB2kpcC9z7I8VZW1fKqWr5w551H1xBJkiSN3VBjVlcBx9L1sJ4PZBvbrecna1wKUFXrgcOATwAvBi4eW6WSJEkazFBh9XzgeLrAugq4HFiRZGGSZcBRwJXALcDTkyxJsjtwNECSXYDdq+ozwBvpemYlSZI0YxYNcdCquj7JrsB3q+rWJJ8EDgeuAQo4raq+B5Dk48Bq4Ebg6n4XuwIXJFlK1yv7pkm3QZIkSeM3SFgFqKoD5zwu4NT+Z8vtTgNO28ouDhtfdZIkSWqB86xKkiSpWYZVSZIkNcuwKkmSpGYZViVJktQsw6okSZKaZViVJElSswyrkiRJapZhVZIkSc0yrEqSJKlZhlVJkiQ1y7AqSZKkZhlWJUmS1CzDqiRJkpplWJUkSVKzDKuSJElqlmFVkiRJzTKsSpIkqVmGVUmSJDXLsCpJkqRmGVYlSZLULMOqJEmSmmVYlSRJUrNSVUPXMDFJfgDcMqHDPR64fULHGoLtm262b3rNctvA9k072ze9Jt22vatq2Xw2fFSF1UlKclVVLR+6jnGxfdPN9k2vWW4b2L5pZ/umV8ttcxiAJEmSmmVYlSRJUrMMq+OzcugCxsz2TTfbN71muW1g+6ad7ZtezbbNMauSJElqlj2rkiRJapZhVZIkSc0yrEqSJKlZhlVJkiQ1y7AqSZKkZv1/R/7nlOPTJfEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 792x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sentences = ['There is a misunderstanding',\n",
    "             'what do you want ?',\n",
    "             'are you mad ?',\n",
    "             'state of the art',\n",
    "             'the exam is going to be hard', \n",
    "             'do you want to play with me ?','i love you', \n",
    "             'how are you doing ?', \n",
    "             'i should tell you that i am quite dangerous', \n",
    "             'Do you have any idea of how to use it ?']\n",
    "\n",
    "for inp_sentence in sentences:\n",
    "    inp_array = inp_sentence.split()\n",
    "    inp_len = len(inp_sentence.split())\n",
    "    trans_sentence, attention_weights = translate_sentence(inp_sentence)\n",
    "    #print(\"\",attention_weights)\n",
    "    trans_array = trans_sentence.split()\n",
    "    trans_len = len(trans_array)\n",
    "    attention_weights = np.array([x for x in attention_weights])\n",
    "    \n",
    "    attention_weights = attention_weights[:trans_len,:inp_len]\n",
    "    plt.figure(figsize=(inp_len, trans_len))\n",
    "    plt.matshow(attention_weights)\n",
    "    plt.xticks(range(inp_len), inp_array, rotation=90)\n",
    "    plt.yticks(range(trans_len), trans_array)\n",
    "    print('EN : ', inp_sentence)\n",
    "    print('FR : ', trans_sentence)\n",
    "    print('-'*30)"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": true,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
